// Prevents additional console window on Windows in release, DO NOT REMOVE!!
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]

use crate::redis_cli::{
    redis_connect, redis_hash_key_values, redis_key_types, redis_string_value, KeyTypes,
};

mod redis_cli;

fn main() {
    tauri::Builder::default()
        .invoke_handler(tauri::generate_handler![
            redis_connect_test,
            redis_keys_block,
            redis_string_value_block,
            redis_hash_value_block
        ])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

#[tauri::command]
fn redis_connect_test(url: String) -> bool {
    let test = tokio::runtime::Runtime::new()
        .unwrap()
        .block_on(redis_connect(url));
    match test {
        Ok(t) => true,
        Err(e) => false,
    }
}

#[tauri::command]
fn redis_keys_block(url: String) -> Vec<KeyTypes> {
    let keys = match tokio::runtime::Runtime::new()
        .unwrap()
        .block_on(redis_connect(url))
    {
        Ok(con) => {
            match tokio::runtime::Runtime::new()
                .unwrap()
                .block_on(redis_key_types(con))
            {
                Ok(keys) => keys,
                Err(e) => {
                    println!("Redis 错误: {:?}", e);
                    Vec::new() // 或者其他错误处理方式，这里简单返回一个空 Vec
                }
            }
        }
        Err(e) => {
            println!("连接错误: {:?}", e);
            Vec::new() // 或者其他错误处理方式，这里简单返回一个空 Vec
        }
    };

    keys
}

#[tauri::command]
fn redis_string_value_block(url: String, key: String) -> String {
    let value = match tokio::runtime::Runtime::new()
        .unwrap()
        .block_on(redis_connect(url))
    {
        Ok(con) => {
            match tokio::runtime::Runtime::new()
                .unwrap()
                .block_on(redis_string_value(con, key))
            {
                Ok(keys) => keys,
                Err(e) => {
                    println!("Redis 错误: {:?}", e);
                    String::from("") // 或者其他错误处理方式，这里简单返回一个空 Vec
                }
            }
        }
        Err(e) => {
            println!("连接错误: {:?}", e);
            String::from("") // 或者其他错误处理方式，这里简单返回一个空 Vec
        }
    };

    value
}

#[tauri::command]
fn redis_hash_value_block(url: String, key: String) -> Vec<(String, String)> {
    let values = match tokio::runtime::Runtime::new()
        .unwrap()
        .block_on(redis_connect(url))
    {
        Ok(con) => {
            match tokio::runtime::Runtime::new()
                .unwrap()
                .block_on(redis_hash_key_values(con, key))
            {
                Ok(keys) => keys,
                Err(e) => {
                    println!("Redis 错误: {:?}", e);
                    Vec::new() // 或者其他错误处理方式，这里简单返回一个空 Vec
                }
            }
        }
        Err(e) => {
            println!("连接错误: {:?}", e);
            Vec::new() // 或者其他错误处理方式，这里简单返回一个空 Vec
        }
    };

    values
}
